Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | from test.test_support import verbose, have_unicode, TestFailed |
2 | import sys | |
3 | ||
4 | # test string formatting operator (I am not sure if this is being tested | |
5 | # elsewhere but, surely, some of the given cases are *not* tested because | |
6 | # they crash python) | |
7 | # test on unicode strings as well | |
8 | ||
9 | overflowok = 1 | |
10 | ||
11 | def testformat(formatstr, args, output=None): | |
12 | if verbose: | |
13 | if output: | |
14 | print "%s %% %s =? %s ..." %\ | |
15 | (repr(formatstr), repr(args), repr(output)), | |
16 | else: | |
17 | print "%s %% %s works? ..." % (repr(formatstr), repr(args)), | |
18 | try: | |
19 | result = formatstr % args | |
20 | except OverflowError: | |
21 | if not overflowok: | |
22 | raise | |
23 | if verbose: | |
24 | print 'overflow (this is fine)' | |
25 | else: | |
26 | if output and result != output: | |
27 | if verbose: | |
28 | print 'no' | |
29 | print "%s %% %s == %s != %s" %\ | |
30 | (repr(formatstr), repr(args), repr(result), repr(output)) | |
31 | else: | |
32 | if verbose: | |
33 | print 'yes' | |
34 | ||
35 | def testboth(formatstr, *args): | |
36 | testformat(formatstr, *args) | |
37 | if have_unicode: | |
38 | testformat(unicode(formatstr), *args) | |
39 | ||
40 | ||
41 | testboth("%.1d", (1,), "1") | |
42 | testboth("%.*d", (sys.maxint,1)) # expect overflow | |
43 | testboth("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001') | |
44 | testboth("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001') | |
45 | testboth("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001') | |
46 | ||
47 | testboth("%f", (1.0,), "1.000000") | |
48 | # these are trying to test the limits of the internal magic-number-length | |
49 | # formatting buffer, if that number changes then these tests are less | |
50 | # effective | |
51 | testboth("%#.*g", (109, -1.e+49/3.)) | |
52 | testboth("%#.*g", (110, -1.e+49/3.)) | |
53 | testboth("%#.*g", (110, -1.e+100/3.)) | |
54 | ||
55 | # test some ridiculously large precision, expect overflow | |
56 | testboth('%12.*f', (123456, 1.0)) | |
57 | ||
58 | # Formatting of long integers. Overflow is not ok | |
59 | overflowok = 0 | |
60 | testboth("%x", 10L, "a") | |
61 | testboth("%x", 100000000000L, "174876e800") | |
62 | testboth("%o", 10L, "12") | |
63 | testboth("%o", 100000000000L, "1351035564000") | |
64 | testboth("%d", 10L, "10") | |
65 | testboth("%d", 100000000000L, "100000000000") | |
66 | ||
67 | big = 123456789012345678901234567890L | |
68 | testboth("%d", big, "123456789012345678901234567890") | |
69 | testboth("%d", -big, "-123456789012345678901234567890") | |
70 | testboth("%5d", -big, "-123456789012345678901234567890") | |
71 | testboth("%31d", -big, "-123456789012345678901234567890") | |
72 | testboth("%32d", -big, " -123456789012345678901234567890") | |
73 | testboth("%-32d", -big, "-123456789012345678901234567890 ") | |
74 | testboth("%032d", -big, "-0123456789012345678901234567890") | |
75 | testboth("%-032d", -big, "-123456789012345678901234567890 ") | |
76 | testboth("%034d", -big, "-000123456789012345678901234567890") | |
77 | testboth("%034d", big, "0000123456789012345678901234567890") | |
78 | testboth("%0+34d", big, "+000123456789012345678901234567890") | |
79 | testboth("%+34d", big, " +123456789012345678901234567890") | |
80 | testboth("%34d", big, " 123456789012345678901234567890") | |
81 | testboth("%.2d", big, "123456789012345678901234567890") | |
82 | testboth("%.30d", big, "123456789012345678901234567890") | |
83 | testboth("%.31d", big, "0123456789012345678901234567890") | |
84 | testboth("%32.31d", big, " 0123456789012345678901234567890") | |
85 | ||
86 | big = 0x1234567890abcdef12345L # 21 hex digits | |
87 | testboth("%x", big, "1234567890abcdef12345") | |
88 | testboth("%x", -big, "-1234567890abcdef12345") | |
89 | testboth("%5x", -big, "-1234567890abcdef12345") | |
90 | testboth("%22x", -big, "-1234567890abcdef12345") | |
91 | testboth("%23x", -big, " -1234567890abcdef12345") | |
92 | testboth("%-23x", -big, "-1234567890abcdef12345 ") | |
93 | testboth("%023x", -big, "-01234567890abcdef12345") | |
94 | testboth("%-023x", -big, "-1234567890abcdef12345 ") | |
95 | testboth("%025x", -big, "-0001234567890abcdef12345") | |
96 | testboth("%025x", big, "00001234567890abcdef12345") | |
97 | testboth("%0+25x", big, "+0001234567890abcdef12345") | |
98 | testboth("%+25x", big, " +1234567890abcdef12345") | |
99 | testboth("%25x", big, " 1234567890abcdef12345") | |
100 | testboth("%.2x", big, "1234567890abcdef12345") | |
101 | testboth("%.21x", big, "1234567890abcdef12345") | |
102 | testboth("%.22x", big, "01234567890abcdef12345") | |
103 | testboth("%23.22x", big, " 01234567890abcdef12345") | |
104 | testboth("%-23.22x", big, "01234567890abcdef12345 ") | |
105 | testboth("%X", big, "1234567890ABCDEF12345") | |
106 | testboth("%#X", big, "0X1234567890ABCDEF12345") | |
107 | testboth("%#x", big, "0x1234567890abcdef12345") | |
108 | testboth("%#x", -big, "-0x1234567890abcdef12345") | |
109 | testboth("%#.23x", -big, "-0x001234567890abcdef12345") | |
110 | testboth("%#+.23x", big, "+0x001234567890abcdef12345") | |
111 | testboth("%# .23x", big, " 0x001234567890abcdef12345") | |
112 | testboth("%#+.23X", big, "+0X001234567890ABCDEF12345") | |
113 | testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345") | |
114 | testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345") | |
115 | testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ") | |
116 | testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345") | |
117 | # next one gets two leading zeroes from precision, and another from the | |
118 | # 0 flag and the width | |
119 | testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345") | |
120 | # same, except no 0 flag | |
121 | testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345") | |
122 | ||
123 | big = 012345670123456701234567012345670L # 32 octal digits | |
124 | testboth("%o", big, "12345670123456701234567012345670") | |
125 | testboth("%o", -big, "-12345670123456701234567012345670") | |
126 | testboth("%5o", -big, "-12345670123456701234567012345670") | |
127 | testboth("%33o", -big, "-12345670123456701234567012345670") | |
128 | testboth("%34o", -big, " -12345670123456701234567012345670") | |
129 | testboth("%-34o", -big, "-12345670123456701234567012345670 ") | |
130 | testboth("%034o", -big, "-012345670123456701234567012345670") | |
131 | testboth("%-034o", -big, "-12345670123456701234567012345670 ") | |
132 | testboth("%036o", -big, "-00012345670123456701234567012345670") | |
133 | testboth("%036o", big, "000012345670123456701234567012345670") | |
134 | testboth("%0+36o", big, "+00012345670123456701234567012345670") | |
135 | testboth("%+36o", big, " +12345670123456701234567012345670") | |
136 | testboth("%36o", big, " 12345670123456701234567012345670") | |
137 | testboth("%.2o", big, "12345670123456701234567012345670") | |
138 | testboth("%.32o", big, "12345670123456701234567012345670") | |
139 | testboth("%.33o", big, "012345670123456701234567012345670") | |
140 | testboth("%34.33o", big, " 012345670123456701234567012345670") | |
141 | testboth("%-34.33o", big, "012345670123456701234567012345670 ") | |
142 | testboth("%o", big, "12345670123456701234567012345670") | |
143 | testboth("%#o", big, "012345670123456701234567012345670") | |
144 | testboth("%#o", -big, "-012345670123456701234567012345670") | |
145 | testboth("%#.34o", -big, "-0012345670123456701234567012345670") | |
146 | testboth("%#+.34o", big, "+0012345670123456701234567012345670") | |
147 | testboth("%# .34o", big, " 0012345670123456701234567012345670") | |
148 | testboth("%#+.34o", big, "+0012345670123456701234567012345670") | |
149 | testboth("%#-+.34o", big, "+0012345670123456701234567012345670") | |
150 | testboth("%#-+37.34o", big, "+0012345670123456701234567012345670 ") | |
151 | testboth("%#+37.34o", big, " +0012345670123456701234567012345670") | |
152 | # next one gets one leading zero from precision | |
153 | testboth("%.33o", big, "012345670123456701234567012345670") | |
154 | # base marker shouldn't change that, since "0" is redundant | |
155 | testboth("%#.33o", big, "012345670123456701234567012345670") | |
156 | # but reduce precision, and base marker should add a zero | |
157 | testboth("%#.32o", big, "012345670123456701234567012345670") | |
158 | # one leading zero from precision, and another from "0" flag & width | |
159 | testboth("%034.33o", big, "0012345670123456701234567012345670") | |
160 | # base marker shouldn't change that | |
161 | testboth("%0#34.33o", big, "0012345670123456701234567012345670") | |
162 | ||
163 | # Some small ints, in both Python int and long flavors). | |
164 | testboth("%d", 42, "42") | |
165 | testboth("%d", -42, "-42") | |
166 | testboth("%d", 42L, "42") | |
167 | testboth("%d", -42L, "-42") | |
168 | testboth("%#x", 1, "0x1") | |
169 | testboth("%#x", 1L, "0x1") | |
170 | testboth("%#X", 1, "0X1") | |
171 | testboth("%#X", 1L, "0X1") | |
172 | testboth("%#o", 1, "01") | |
173 | testboth("%#o", 1L, "01") | |
174 | testboth("%#o", 0, "0") | |
175 | testboth("%#o", 0L, "0") | |
176 | testboth("%o", 0, "0") | |
177 | testboth("%o", 0L, "0") | |
178 | testboth("%d", 0, "0") | |
179 | testboth("%d", 0L, "0") | |
180 | testboth("%#x", 0, "0x0") | |
181 | testboth("%#x", 0L, "0x0") | |
182 | testboth("%#X", 0, "0X0") | |
183 | testboth("%#X", 0L, "0X0") | |
184 | ||
185 | testboth("%x", 0x42, "42") | |
186 | testboth("%x", -0x42, "-42") | |
187 | testboth("%x", 0x42L, "42") | |
188 | testboth("%x", -0x42L, "-42") | |
189 | ||
190 | testboth("%o", 042, "42") | |
191 | testboth("%o", -042, "-42") | |
192 | testboth("%o", 042L, "42") | |
193 | testboth("%o", -042L, "-42") | |
194 | ||
195 | # Test exception for unknown format characters | |
196 | if verbose: | |
197 | print 'Testing exceptions' | |
198 | ||
199 | def test_exc(formatstr, args, exception, excmsg): | |
200 | try: | |
201 | testformat(formatstr, args) | |
202 | except exception, exc: | |
203 | if str(exc) == excmsg: | |
204 | if verbose: | |
205 | print "yes" | |
206 | else: | |
207 | if verbose: print 'no' | |
208 | print 'Unexpected ', exception, ':', repr(str(exc)) | |
209 | except: | |
210 | if verbose: print 'no' | |
211 | print 'Unexpected exception' | |
212 | raise | |
213 | else: | |
214 | raise TestFailed, 'did not get expected exception: %s' % excmsg | |
215 | ||
216 | test_exc('abc %a', 1, ValueError, | |
217 | "unsupported format character 'a' (0x61) at index 5") | |
218 | if have_unicode: | |
219 | test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError, | |
220 | "unsupported format character '?' (0x3000) at index 5") | |
221 | ||
222 | test_exc('%d', '1', TypeError, "int argument required") | |
223 | test_exc('%g', '1', TypeError, "float argument required") | |
224 | test_exc('no format', '1', TypeError, | |
225 | "not all arguments converted during string formatting") | |
226 | test_exc('no format', u'1', TypeError, | |
227 | "not all arguments converted during string formatting") | |
228 | test_exc(u'no format', '1', TypeError, | |
229 | "not all arguments converted during string formatting") | |
230 | test_exc(u'no format', u'1', TypeError, | |
231 | "not all arguments converted during string formatting") | |
232 | ||
233 | if sys.maxint == 2**31-1: | |
234 | # crashes 2.2.1 and earlier: | |
235 | try: | |
236 | "%*d"%(sys.maxint, -127) | |
237 | except MemoryError: | |
238 | pass | |
239 | else: | |
240 | raise TestFailed, '"%*d"%(sys.maxint, -127) should fail' |